const userModel = require("../models/usersModel")
// Miami加密模块
const bcrypt = require('bcrypt'); // 暂时未用，md5更OK
// md5加密
const md5 = require('md5')
// 表单验证
const { validationResult } = require("express-validator")
const jwt = require('jsonwebtoken');
// 用户注册--添加用户
exports.register = async (req, res) => {
    const { username, password, email, phone, role_id, truename } = req.body;
    console.log(username, password, email, phone, role_id, truename)

    try {
        // 1. 检查用户名是否已存在
        const userExists = await userModel.checkUserExists(username);
        if (userExists) {
            return res.status(409).json({
                code: 409,
                msg: '用户名已存在'
            });
        }

        // 2. 检查邮箱是否已存在
        const emailExists = await userModel.checkEmailExists(email);
        if (emailExists) {
            return res.status(409).json({
                code: 409,
                msg: '邮箱已被注册'
            });
        }

        // 3. 密码加密（加盐哈希）
        const saltRounds = 10;
        const hashedPassword = await bcrypt.hash(password, saltRounds);

        // 4. 创建用户
        const result = await userModel.createUser(
            username,
            hashedPassword,
            email,
            phone,
            role_id,
            truename,
        );

        // 5. 生成JWT Token
        const token = jwt.sign(
            { id: result.insertId, username },
            process.env.JWT_SECRET || '39qw89r23890',
            { expiresIn: '24h' }
        );

        res.status(201).json({
            code: 0,
            msg: '注册成功',
            data: {
                userId: result.insertId,
                token
            }
        });

    } catch (error) {
        console.error('注册错误:', error);
        res.status(500).json({
            code: 500,
            msg: '服务器内部错误'
        });
    }
};

// 用户登录
exports.login = async (req, res) => {
    try {
        const { username, password } = req.body;

        // 使用模型查询用户
        const result = await new Promise((resolve, reject) => {
            userModel.login(username, md5(password), (error, result) => {
                if (error) reject(error);
                else resolve(result);
            });
        });

        if (!result || result.length === 0) {
            return res.status(401).json({
                code: 401,
                msg: "用户名或密码错误"
            });
        }

        // 生成 JWT Token
        const token = jwt.sign(
            {
                id: result[0].id,
                username: result[0].username,
                role: result[0].rolecode,
            },
            '39qw89r23890', // 密钥
            { expiresIn: '24h' } // 24小时过期
        );

        res.json({
            code: 0,
            msg: "登录成功！",
            data: {
                userInfo: { ...result[0] },
                token
            }
        });

    } catch (error) {
        console.error('登录错误:', error);
        res.status(422).json({
            code: -1,
            msg: error,
            data: null
        });
    }
};

// 退出登录
exports.logout = (req, res) => {
    // 无状态JWT不需要服务器端处理退出
    // 客户端只需删除本地存储的token即可
    res.json({
        code: 0,
        msg: "退出成功，请客户端删除本地token"
    });
};

// 检查token是否有效
exports.checkToken = (req, res) => {
    const authHeader = req.headers.authorization;
    const token = authHeader?.split(' ')[1];

    if (!token) {
        return res.status(401).json({
            code: 401,
            msg: "未提供token"
        });
    }

    try {
        // 直接验证token（包含过期检查）
        const decoded = jwt.verify(token, '39qw89r23890');

        // 检查token是否即将过期（30分钟内）
        const now = Math.floor(Date.now() / 1000);
        const isNearExpiry = (decoded.exp - now) < 1800;

        res.status(200).json({
            code: 200,
            msg: "token有效",
            isNearExpiry, // 告诉客户端token是否快过期
            expiresAt: decoded.exp // 过期时间戳
        });

    } catch (error) {
        if (error instanceof jwt.TokenExpiredError) {
            return res.status(403).json({
                code: 403,
                msg: "token已过期"
            });
        }

        if (error instanceof jwt.JsonWebTokenError) {
            return res.status(400).json({
                code: 400,
                msg: "无效的token"
            });
        }

        console.error('检查token错误:', error);
        res.status(500).json({
            code: 500,
            msg: "服务器内部错误"
        });
    }
};

// 刷新token
exports.refreshToken = (req, res, next) => {
    const authHeader = req.headers.authorization;
    const token = authHeader?.split(' ')[1]; // 获取 Bearer Token
    // const token = authHeader.startsWith('Bearer ')
    // ? authHeader.slice(7).trim()
    // : authHeader.trim();

    if (!token) {
        // 未提供 Token，不阻塞，继续执行后续中间件
        console.log('未提供 Token，继续执行后续中间件');
        return next();
    }

    try {
        // 1. 解码 Token（不验证签名和过期时间）
        const decoded = jwt.decode(token, { complete: true });
        if (!decoded) {
            // Token 格式无效，但不阻塞
            console.log('无效的 Token 格式，继续执行后续中间件');
            return next();
        }

        const { id, username, role, exp } = decoded.payload;
        const now = Math.floor(Date.now() / 1000); // 当前时间（秒）

        // 2. 检查 Token 是否已过期
        if (exp < now) {
            // Token 已过期，但不阻塞
            console.log('Token 已过期，继续执行后续中间件');
            return next();
        }

        // 3. 检查 Token 是否即将过期（例如 30 分钟内过期）
        const isNearExpiry = (exp - now) < 1800; // 30 分钟 = 1800 秒

        if (isNearExpiry) {
            // 生成新的 Token（有效期 24 小时）
            const newToken = jwt.sign(
                { id, username, role },
                '39qw89r23890',
                { expiresIn: '24h' }
            );

            // 将新 Token 附加到响应对象，供后续中间件或路由使用
            res.setHeader('New-Token', newToken); // 通过 Header 返回
            console.log('生成新 Token:', newToken);
        }

        // 继续执行后续中间件
        next();

    } catch (error) {
        // 处理 JWT 错误（如篡改）
        if (error instanceof jwt.JsonWebTokenError) {
            console.log('无效的 Token，继续执行后续中间件');
            return next();
        }

        // 其他错误
        console.error("刷新 Token 时出错:", error);
        return next(); // 即使出错也不阻塞
    }
};


// 用户的删除--软删除
exports.delete_f = (req, res) => {
    let { id } = req.query
    let p = userModel.deleteuser_f(id)
    p.then((results) => {
        console.log(results)
        res.json({ code: 0, msg: "用户禁用成功！", results })
    }).catch((error) => {
        console.log(error)
        res.json({ code: -1, msg: "用户禁用失败！", error })
    })
}

// 用户的删除--启用
exports.start = (req, res) => {
    let { id } = req.query
    let p = userModel.startuser(id)
    p.then((results) => {
        console.log(results)
        res.json({ code: 0, msg: "用户启用成功！", results })
    }).catch((error) => {
        console.log(error)
        res.json({ code: -1, msg: "用户启用失败！", error })
    })
}
// 用户的删除--真删除
exports.delete_t = (req, res) => {
    let { id } = req.query
    let p = userModel.deleteuser_t(id)
    p.then((results) => {
        console.log(results)
        res.json({ code: 0, msg: "用户删除成功！", results })
    }).catch((error) => {
        console.log(error)
        res.json({ code: -1, msg: "用户删除失败！", error })
    })
}
// 用户的列表搜索页
exports.userlist_c = (req, res) => {
    // validator表单验证
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
        return res.status(422).json({ errors: errors.array() });
    }
    // 其他内容
    let { username, userrole, page_size, page } = req.query
    let p = userModel.userlist(username, userrole, page_size, page)
    p.then((results) => {
        console.log(results)
        res.json({ code: 0, msg: "用户列表请求成功！", results })
    }).catch((error) => {
        console.log(error)
        res.json({ code: -1, msg: "用户列表请求失败！", error })
    })
}
// 用户的修改获取数据
exports.edit_get_c = (req, res) => {
    let { id } = req.query
    let p = userModel.edit_get(id)
    p.then((results) => {
        console.log(results)
        res.json({ code: 0, msg: "用户修改请求成功！", results })
    }).catch((error) => {
        console.log(error)
        res.json({ code: -1, msg: "用户修改请求失败！", error })
    })
}
// 用户的修改保存数据
exports.edit_set_c = (req, res) => {
    // validator表单验证
    // const errors = validationResult(req);
    // if (!errors.isEmpty()) {
    //     return res.status(422).json({ errors: errors.array() });
    // }
    // 其他内容
    let { id, username, email, phone, truename, role_id } = req.body
    console.log("参数：：：",id, username, email, phone, truename, role_id)
    let p = userModel.edit_set(Number(id), username, email, phone, truename, role_id)
    p.then((results) => {
        console.log(results)
        res.json({ code: 0, msg: "用户修改保存成功！", results })
    }).catch((error) => {
        console.log(error)
        res.json({ code: -1, msg: "用户修改保存失败！", error })
    })
}

// 用户个人信息获取数据
exports.per_edit_get = (req, res) => {
    // 从请求头中获取token
    // 从请求头中获取Authorization字段，并提取token
    const authHeader = req.headers.authorization;
    const token = authHeader ? authHeader.split(' ')[1] : null; // 提取token
    if (!token) {
        return res.status(401).json({ code: 401, msg: "未提供token" });
    }
    const decoded = jwt.verify(token, '39qw89r23890');
    console.log("decoded————————", decoded)
    const { id } = decoded;

    let p = userModel.per_edit_get(id)
    p.then((results) => {
        console.log(results)
        res.json({ code: 0, msg: "用户修改请求成功！", results })
    }).catch((error) => {
        console.log(error)
        res.json({ code: -1, msg: "用户修改请求失败！", error })
    })
}
// 用户个人信息的修改
exports.per_edit_set = (req, res) => {
    // validator表单验证
    // const errors = validationResult(req);
    // if (!errors.isEmpty()) {
    //     return res.status(422).json({ errors: errors.array() });
    // }
    // 从请求头中获取token
    // 从请求头中获取Authorization字段，并提取token
    const authHeader = req.headers.authorization;
    const token = authHeader ? authHeader.split(' ')[1] : null; // 提取token
    if (!token) {
        return res.status(401).json({ code: 401, msg: "未提供token" });
    }
    const decoded = jwt.verify(token, '39qw89r23890');
    console.log("decoded————————", decoded)
    const { id } = decoded;
    // 当前时间戳
    let update_time = Date.now()
    let { username, email, phone, truename } = req.body
    let p = userModel.per_edit_set(id, username, email, phone, truename, update_time)
    p.then((results) => {
        console.log(results)
        res.json({ code: 0, msg: "用户修改保存成功！", results })
    }).catch((error) => {
        console.log(error)
        res.status(400).json({ code: -1, msg: "用户修改保存失败！", error })
    })
}
// 用户密码重置为123456
exports.reset_pwd = (req, res) => {
    let { id } = req.query
    let p = userModel.reset_password(id)
    p.then((results) => {
        console.log(results)
        res.json({ code: 0, msg: "用户密码重置成功！", results })
    }).catch((error) => {
        console.log(error)
        res.json({ code: -1, msg: "用户密码重置失败！", error })
    })
}

// 用户修改个人密码的接口
exports.change_pwd = async (req, res) => {
    try {
        // 1. 验证token
        const authHeader = req.headers.authorization;
        if (!authHeader) {
            return res.status(401).json({ code: 401, msg: "未提供token" });
        }

        const token = authHeader.split(' ')[1];
        if (!token) {
            return res.status(401).json({ code: 401, msg: "token格式不正确" });
        }

        // 2. 验证密码输入
        const { oldPassword, newPassword, confirmPassword } = req.body;

        // 检查必填字段
        if (!oldPassword || !newPassword || !confirmPassword) {
            return res.status(400).json({
                code: 400,
                msg: "请提供旧密码、新密码和确认密码"
            });
        }

        // 检查新密码和确认密码是否一致
        if (newPassword !== confirmPassword) {
            return res.status(400).json({
                code: 400,
                msg: "新密码和确认密码不一致"
            });
        }

        // 检查新密码是否与旧密码相同
        if (oldPassword === newPassword) {
            return res.status(400).json({
                code: 400,
                msg: "新密码不能与旧密码相同"
            });
        }

        // 3. 验证token并获取用户ID
        const decoded = jwt.verify(token, '39qw89r23890');
        const { id } = decoded;

        // 4. 验证旧密码是否正确（这里假设userModel有一个验证密码的方法）
        const user = await userModel.findById(id);
        if (!user) {
            return res.status(200).json({ code: 404, msg: "用户不存在" });
        }

        const isOldPasswordCorrect = await userModel.verifyPassword(id, md5(oldPassword));
        console.log('idusaiuoiahuisugi--------', isOldPasswordCorrect)

        if (!isOldPasswordCorrect || isOldPasswordCorrect.length === 0) {
            return res.status(400).json({ code: 400, msg: "旧密码不正确" });
        }

        // 5. 更新密码
        const hashedPassword = md5(newPassword);
        const result = await userModel.change_pwd(id, hashedPassword);

        // 6. 返回成功响应
        return res.json({
            code: 0,
            msg: "密码修改成功",
            data: {
                userId: id,
                updatedAt: new Date()
            }
        });

    } catch (error) {
        console.error("密码修改失败:", error);

        // 处理JWT验证错误
        if (error.name === 'JsonWebTokenError') {
            return res.status(401).json({ code: 401, msg: "无效的token" });
        }

        if (error.name === 'TokenExpiredError') {
            return res.status(401).json({ code: 401, msg: "token已过期" });
        }

        // 其他错误
        return res.status(500).json({
            code: 500,
            msg: "密码修改失败，请稍后重试",
            error: process.env.NODE_ENV === 'development' ? error.message : undefined
        });
    }
};

// 老师列表
exports.teacher_list = (req, res) => {
    // 从请求头中获取token
    // 从请求头中获取Authorization字段，并提取token
    const authHeader = req.headers.authorization;
    const token = authHeader ? authHeader.split(' ')[1] : null; // 提取token
    if (!token) {
        return res.status(401).json({ code: 401, msg: "未提供token" });
    }
    let p = userModel.teacher_list()
    p.then((results) => {
        console.log(results)
        res.json({ code: 0, msg: "老师列表请求成功！", results })
    }).catch((error) => {
        console.log(error)
        res.json({ code: -1, msg: "老师列表请求失败！", error })
    })
}